﻿using System;
using System.Diagnostics;
using System.IO;
using Google.ProtocolBuffers;
using Google.ProtocolBuffers.Descriptors;
using Google.ProtocolBuffers.FieldAccess;

namespace com.gexin.rp.sdk.dto
{
	// Token: 0x0200001F RID: 31
	[DebuggerNonUserCode]
	public sealed class InnerFiled : GeneratedMessage<InnerFiled, InnerFiled.Builder>
	{
		// Token: 0x060003D5 RID: 981 RVA: 0x00008A32 File Offset: 0x00006C32
		private InnerFiled()
		{
		}

		// Token: 0x170001E7 RID: 487
		// (get) Token: 0x060003D6 RID: 982 RVA: 0x00008A57 File Offset: 0x00006C57
		public static InnerFiled DefaultInstance
		{
			get
			{
				return InnerFiled.defaultInstance;
			}
		}

		// Token: 0x170001E8 RID: 488
		// (get) Token: 0x060003D7 RID: 983 RVA: 0x00008A5E File Offset: 0x00006C5E
		public override InnerFiled DefaultInstanceForType
		{
			get
			{
				return InnerFiled.DefaultInstance;
			}
		}

		// Token: 0x170001E9 RID: 489
		// (get) Token: 0x060003D8 RID: 984 RVA: 0x00002579 File Offset: 0x00000779
		protected override InnerFiled ThisMessage
		{
			get
			{
				return this;
			}
		}

		// Token: 0x170001EA RID: 490
		// (get) Token: 0x060003D9 RID: 985 RVA: 0x00008A65 File Offset: 0x00006C65
		public static MessageDescriptor Descriptor
		{
			get
			{
				return GtReq.internal__static_com_gexin_rp_sdk_dto_InnerFiled__Descriptor;
			}
		}

		// Token: 0x170001EB RID: 491
		// (get) Token: 0x060003DA RID: 986 RVA: 0x00008A6C File Offset: 0x00006C6C
		protected override FieldAccessorTable<InnerFiled, InnerFiled.Builder> InternalFieldAccessors
		{
			get
			{
				return GtReq.internal__static_com_gexin_rp_sdk_dto_InnerFiled__FieldAccessorTable;
			}
		}

		// Token: 0x170001EC RID: 492
		// (get) Token: 0x060003DB RID: 987 RVA: 0x00008A73 File Offset: 0x00006C73
		public bool HasKey
		{
			get
			{
				return this.hasKey;
			}
		}

		// Token: 0x170001ED RID: 493
		// (get) Token: 0x060003DC RID: 988 RVA: 0x00008A7B File Offset: 0x00006C7B
		public string Key
		{
			get
			{
				return this.key_;
			}
		}

		// Token: 0x170001EE RID: 494
		// (get) Token: 0x060003DD RID: 989 RVA: 0x00008A83 File Offset: 0x00006C83
		public bool HasVal
		{
			get
			{
				return this.hasVal;
			}
		}

		// Token: 0x170001EF RID: 495
		// (get) Token: 0x060003DE RID: 990 RVA: 0x00008A8B File Offset: 0x00006C8B
		public string Val
		{
			get
			{
				return this.val_;
			}
		}

		// Token: 0x170001F0 RID: 496
		// (get) Token: 0x060003DF RID: 991 RVA: 0x00008A93 File Offset: 0x00006C93
		public bool HasType
		{
			get
			{
				return this.hasType;
			}
		}

		// Token: 0x170001F1 RID: 497
		// (get) Token: 0x060003E0 RID: 992 RVA: 0x00008A9B File Offset: 0x00006C9B
		public InnerFiled.Types.Type Type
		{
			get
			{
				return this.type_;
			}
		}

		// Token: 0x170001F2 RID: 498
		// (get) Token: 0x060003E1 RID: 993 RVA: 0x00008AA3 File Offset: 0x00006CA3
		public override bool IsInitialized
		{
			get
			{
				return this.hasKey && this.hasVal && this.hasType;
			}
		}

		// Token: 0x060003E2 RID: 994 RVA: 0x00008AC4 File Offset: 0x00006CC4
		public override void WriteTo(ICodedOutputStream output)
		{
			this.CalcSerializedSize();
			string[] innerFiledFieldNames = InnerFiled._innerFiledFieldNames;
			if (this.hasKey)
			{
				output.WriteString(1, innerFiledFieldNames[0], this.Key);
			}
			if (this.hasVal)
			{
				output.WriteString(2, innerFiledFieldNames[2], this.Val);
			}
			if (this.hasType)
			{
				output.WriteEnum(3, innerFiledFieldNames[1], (int)this.Type, this.Type);
			}
			this.UnknownFields.WriteTo(output);
		}

		// Token: 0x170001F3 RID: 499
		// (get) Token: 0x060003E3 RID: 995 RVA: 0x00008B40 File Offset: 0x00006D40
		public override int SerializedSize
		{
			get
			{
				int num = this.memoizedSerializedSize;
				if (num != -1)
				{
					return num;
				}
				return this.CalcSerializedSize();
			}
		}

		// Token: 0x060003E4 RID: 996 RVA: 0x00008B60 File Offset: 0x00006D60
		private int CalcSerializedSize()
		{
			int num = this.memoizedSerializedSize;
			if (num != -1)
			{
				return num;
			}
			num = 0;
			if (this.hasKey)
			{
				num += CodedOutputStream.ComputeStringSize(1, this.Key);
			}
			if (this.hasVal)
			{
				num += CodedOutputStream.ComputeStringSize(2, this.Val);
			}
			if (this.hasType)
			{
				num += CodedOutputStream.ComputeEnumSize(3, (int)this.Type);
			}
			num += this.UnknownFields.SerializedSize;
			this.memoizedSerializedSize = num;
			return num;
		}

		// Token: 0x060003E5 RID: 997 RVA: 0x00008BD7 File Offset: 0x00006DD7
		public static InnerFiled ParseFrom(ByteString data)
		{
			return InnerFiled.CreateBuilder().MergeFrom(data).BuildParsed();
		}

		// Token: 0x060003E6 RID: 998 RVA: 0x00008BE9 File Offset: 0x00006DE9
		public static InnerFiled ParseFrom(ByteString data, ExtensionRegistry extensionRegistry)
		{
			return InnerFiled.CreateBuilder().MergeFrom(data, extensionRegistry).BuildParsed();
		}

		// Token: 0x060003E7 RID: 999 RVA: 0x00008BFC File Offset: 0x00006DFC
		public static InnerFiled ParseFrom(byte[] data)
		{
			return InnerFiled.CreateBuilder().MergeFrom(data).BuildParsed();
		}

		// Token: 0x060003E8 RID: 1000 RVA: 0x00008C0E File Offset: 0x00006E0E
		public static InnerFiled ParseFrom(byte[] data, ExtensionRegistry extensionRegistry)
		{
			return InnerFiled.CreateBuilder().MergeFrom(data, extensionRegistry).BuildParsed();
		}

		// Token: 0x060003E9 RID: 1001 RVA: 0x00008C21 File Offset: 0x00006E21
		public static InnerFiled ParseFrom(Stream input)
		{
			return InnerFiled.CreateBuilder().MergeFrom(input).BuildParsed();
		}

		// Token: 0x060003EA RID: 1002 RVA: 0x00008C33 File Offset: 0x00006E33
		public static InnerFiled ParseFrom(Stream input, ExtensionRegistry extensionRegistry)
		{
			return InnerFiled.CreateBuilder().MergeFrom(input, extensionRegistry).BuildParsed();
		}

		// Token: 0x060003EB RID: 1003 RVA: 0x00008C46 File Offset: 0x00006E46
		public static InnerFiled ParseDelimitedFrom(Stream input)
		{
			return InnerFiled.CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
		}

		// Token: 0x060003EC RID: 1004 RVA: 0x00008C58 File Offset: 0x00006E58
		public static InnerFiled ParseDelimitedFrom(Stream input, ExtensionRegistry extensionRegistry)
		{
			return InnerFiled.CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
		}

		// Token: 0x060003ED RID: 1005 RVA: 0x00008C6B File Offset: 0x00006E6B
		public static InnerFiled ParseFrom(ICodedInputStream input)
		{
			return InnerFiled.CreateBuilder().MergeFrom(input).BuildParsed();
		}

		// Token: 0x060003EE RID: 1006 RVA: 0x00008C7D File Offset: 0x00006E7D
		public static InnerFiled ParseFrom(ICodedInputStream input, ExtensionRegistry extensionRegistry)
		{
			return InnerFiled.CreateBuilder().MergeFrom(input, extensionRegistry).BuildParsed();
		}

		// Token: 0x060003EF RID: 1007 RVA: 0x00002579 File Offset: 0x00000779
		private InnerFiled MakeReadOnly()
		{
			return this;
		}

		// Token: 0x060003F0 RID: 1008 RVA: 0x00008C90 File Offset: 0x00006E90
		public static InnerFiled.Builder CreateBuilder()
		{
			return new InnerFiled.Builder();
		}

		// Token: 0x060003F1 RID: 1009 RVA: 0x00008C97 File Offset: 0x00006E97
		public override InnerFiled.Builder ToBuilder()
		{
			return InnerFiled.CreateBuilder(this);
		}

		// Token: 0x060003F2 RID: 1010 RVA: 0x00008C90 File Offset: 0x00006E90
		public override InnerFiled.Builder CreateBuilderForType()
		{
			return new InnerFiled.Builder();
		}

		// Token: 0x060003F3 RID: 1011 RVA: 0x00008C9F File Offset: 0x00006E9F
		public static InnerFiled.Builder CreateBuilder(InnerFiled prototype)
		{
			return new InnerFiled.Builder(prototype);
		}

		// Token: 0x060003F4 RID: 1012 RVA: 0x00008CA8 File Offset: 0x00006EA8
		static InnerFiled()
		{
			FileDescriptor descriptor = GtReq.Descriptor;
		}

		// Token: 0x04000279 RID: 633
		private static readonly InnerFiled defaultInstance = new InnerFiled().MakeReadOnly();

		// Token: 0x0400027A RID: 634
		private static readonly string[] _innerFiledFieldNames = new string[]
		{
			"key",
			"type",
			"val"
		};

		// Token: 0x0400027B RID: 635
		private static readonly uint[] _innerFiledFieldTags = new uint[]
		{
			10u,
			24u,
			18u
		};

		// Token: 0x0400027C RID: 636
		public const int KeyFieldNumber = 1;

		// Token: 0x0400027D RID: 637
		private bool hasKey;

		// Token: 0x0400027E RID: 638
		private string key_ = "";

		// Token: 0x0400027F RID: 639
		public const int ValFieldNumber = 2;

		// Token: 0x04000280 RID: 640
		private bool hasVal;

		// Token: 0x04000281 RID: 641
		private string val_ = "";

		// Token: 0x04000282 RID: 642
		public const int TypeFieldNumber = 3;

		// Token: 0x04000283 RID: 643
		private bool hasType;

		// Token: 0x04000284 RID: 644
		private InnerFiled.Types.Type type_;

		// Token: 0x04000285 RID: 645
		private int memoizedSerializedSize = -1;

		// Token: 0x0200006E RID: 110
		[DebuggerNonUserCode]
		public static class Types
		{
			// Token: 0x02000083 RID: 131
			public enum Type
			{
				// Token: 0x040003B5 RID: 949
				str,
				// Token: 0x040003B6 RID: 950
				int32,
				// Token: 0x040003B7 RID: 951
				int64,
				// Token: 0x040003B8 RID: 952
				floa,
				// Token: 0x040003B9 RID: 953
				doub,
				// Token: 0x040003BA RID: 954
				boole
			}
		}

		// Token: 0x0200006F RID: 111
		[DebuggerNonUserCode]
		public sealed class Builder : GeneratedBuilder<InnerFiled, InnerFiled.Builder>
		{
			// Token: 0x1700041A RID: 1050
			// (get) Token: 0x06000A62 RID: 2658 RVA: 0x00002579 File Offset: 0x00000779
			protected override InnerFiled.Builder ThisBuilder
			{
				get
				{
					return this;
				}
			}

			// Token: 0x06000A63 RID: 2659 RVA: 0x0001869C File Offset: 0x0001689C
			public Builder()
			{
				this.result = InnerFiled.DefaultInstance;
				this.resultIsReadOnly = true;
			}

			// Token: 0x06000A64 RID: 2660 RVA: 0x000186B6 File Offset: 0x000168B6
			internal Builder(InnerFiled cloneFrom)
			{
				this.result = cloneFrom;
				this.resultIsReadOnly = true;
			}

			// Token: 0x06000A65 RID: 2661 RVA: 0x000186CC File Offset: 0x000168CC
			private InnerFiled PrepareBuilder()
			{
				if (this.resultIsReadOnly)
				{
					InnerFiled other = this.result;
					this.result = new InnerFiled();
					this.resultIsReadOnly = false;
					this.MergeFrom(other);
				}
				return this.result;
			}

			// Token: 0x1700041B RID: 1051
			// (get) Token: 0x06000A66 RID: 2662 RVA: 0x00018708 File Offset: 0x00016908
			public override bool IsInitialized
			{
				get
				{
					return this.result.IsInitialized;
				}
			}

			// Token: 0x1700041C RID: 1052
			// (get) Token: 0x06000A67 RID: 2663 RVA: 0x00018715 File Offset: 0x00016915
			protected override InnerFiled MessageBeingBuilt
			{
				get
				{
					return this.PrepareBuilder();
				}
			}

			// Token: 0x06000A68 RID: 2664 RVA: 0x0001871D File Offset: 0x0001691D
			public override InnerFiled.Builder Clear()
			{
				this.result = InnerFiled.DefaultInstance;
				this.resultIsReadOnly = true;
				return this;
			}

			// Token: 0x06000A69 RID: 2665 RVA: 0x00018732 File Offset: 0x00016932
			public override InnerFiled.Builder Clone()
			{
				if (this.resultIsReadOnly)
				{
					return new InnerFiled.Builder(this.result);
				}
				return new InnerFiled.Builder().MergeFrom(this.result);
			}

			// Token: 0x1700041D RID: 1053
			// (get) Token: 0x06000A6A RID: 2666 RVA: 0x00018758 File Offset: 0x00016958
			public override MessageDescriptor DescriptorForType
			{
				get
				{
					return InnerFiled.Descriptor;
				}
			}

			// Token: 0x1700041E RID: 1054
			// (get) Token: 0x06000A6B RID: 2667 RVA: 0x00008A5E File Offset: 0x00006C5E
			public override InnerFiled DefaultInstanceForType
			{
				get
				{
					return InnerFiled.DefaultInstance;
				}
			}

			// Token: 0x06000A6C RID: 2668 RVA: 0x0001875F File Offset: 0x0001695F
			public override InnerFiled BuildPartial()
			{
				if (this.resultIsReadOnly)
				{
					return this.result;
				}
				this.resultIsReadOnly = true;
				return this.result.MakeReadOnly();
			}

			// Token: 0x06000A6D RID: 2669 RVA: 0x00018782 File Offset: 0x00016982
			public override InnerFiled.Builder MergeFrom(IMessage other)
			{
				if (other is InnerFiled)
				{
					return this.MergeFrom((InnerFiled)other);
				}
				base.MergeFrom(other);
				return this;
			}

			// Token: 0x06000A6E RID: 2670 RVA: 0x000187A4 File Offset: 0x000169A4
			public override InnerFiled.Builder MergeFrom(InnerFiled other)
			{
				if (other == InnerFiled.DefaultInstance)
				{
					return this;
				}
				this.PrepareBuilder();
				if (other.HasKey)
				{
					this.Key = other.Key;
				}
				if (other.HasVal)
				{
					this.Val = other.Val;
				}
				if (other.HasType)
				{
					this.Type = other.Type;
				}
				this.MergeUnknownFields(other.UnknownFields);
				return this;
			}

			// Token: 0x06000A6F RID: 2671 RVA: 0x0001880C File Offset: 0x00016A0C
			public override InnerFiled.Builder MergeFrom(ICodedInputStream input)
			{
				return this.MergeFrom(input, ExtensionRegistry.Empty);
			}

			// Token: 0x06000A70 RID: 2672 RVA: 0x0001881C File Offset: 0x00016A1C
			public override InnerFiled.Builder MergeFrom(ICodedInputStream input, ExtensionRegistry extensionRegistry)
			{
				this.PrepareBuilder();
				UnknownFieldSet.Builder builder = null;
				uint num;
				string text;
				while (input.ReadTag(out num, out text))
				{
					if (num == 0u && text != null)
					{
						int num2 = Array.BinarySearch<string>(InnerFiled._innerFiledFieldNames, text, StringComparer.Ordinal);
						if (num2 < 0)
						{
							if (builder == null)
							{
								builder = UnknownFieldSet.CreateBuilder(this.UnknownFields);
							}
							this.ParseUnknownField(input, builder, extensionRegistry, num, text);
							continue;
						}
						num = InnerFiled._innerFiledFieldTags[num2];
					}
					if (num <= 10u)
					{
						if (num == 0u)
						{
							throw InvalidProtocolBufferException.InvalidTag();
						}
						if (num == 10u)
						{
							this.result.hasKey = input.ReadString(ref this.result.key_);
							continue;
						}
					}
					else
					{
						if (num == 18u)
						{
							this.result.hasVal = input.ReadString(ref this.result.val_);
							continue;
						}
						if (num == 24u)
						{
							object obj;
							if (input.ReadEnum<InnerFiled.Types.Type>(ref this.result.type_, out obj))
							{
								this.result.hasType = true;
								continue;
							}
							if (obj is int)
							{
								if (builder == null)
								{
									builder = UnknownFieldSet.CreateBuilder(this.UnknownFields);
								}
								builder.MergeVarintField(3, (ulong)((long)((int)obj)));
								continue;
							}
							continue;
						}
					}
					if (WireFormat.IsEndGroupTag(num))
					{
						if (builder != null)
						{
							this.UnknownFields = builder.Build();
						}
						return this;
					}
					if (builder == null)
					{
						builder = UnknownFieldSet.CreateBuilder(this.UnknownFields);
					}
					this.ParseUnknownField(input, builder, extensionRegistry, num, text);
				}
				if (builder != null)
				{
					this.UnknownFields = builder.Build();
				}
				return this;
			}

			// Token: 0x1700041F RID: 1055
			// (get) Token: 0x06000A71 RID: 2673 RVA: 0x0001897C File Offset: 0x00016B7C
			public bool HasKey
			{
				get
				{
					return this.result.hasKey;
				}
			}

			// Token: 0x17000420 RID: 1056
			// (get) Token: 0x06000A72 RID: 2674 RVA: 0x00018989 File Offset: 0x00016B89
			// (set) Token: 0x06000A73 RID: 2675 RVA: 0x00018996 File Offset: 0x00016B96
			public string Key
			{
				get
				{
					return this.result.Key;
				}
				set
				{
					this.SetKey(value);
				}
			}

			// Token: 0x06000A74 RID: 2676 RVA: 0x000189A0 File Offset: 0x00016BA0
			public InnerFiled.Builder SetKey(string value)
			{
				ThrowHelper.ThrowIfNull(value, "value");
				this.PrepareBuilder();
				this.result.hasKey = true;
				this.result.key_ = value;
				return this;
			}

			// Token: 0x06000A75 RID: 2677 RVA: 0x000189CD File Offset: 0x00016BCD
			public InnerFiled.Builder ClearKey()
			{
				this.PrepareBuilder();
				this.result.hasKey = false;
				this.result.key_ = "";
				return this;
			}

			// Token: 0x17000421 RID: 1057
			// (get) Token: 0x06000A76 RID: 2678 RVA: 0x000189F3 File Offset: 0x00016BF3
			public bool HasVal
			{
				get
				{
					return this.result.hasVal;
				}
			}

			// Token: 0x17000422 RID: 1058
			// (get) Token: 0x06000A77 RID: 2679 RVA: 0x00018A00 File Offset: 0x00016C00
			// (set) Token: 0x06000A78 RID: 2680 RVA: 0x00018A0D File Offset: 0x00016C0D
			public string Val
			{
				get
				{
					return this.result.Val;
				}
				set
				{
					this.SetVal(value);
				}
			}

			// Token: 0x06000A79 RID: 2681 RVA: 0x00018A17 File Offset: 0x00016C17
			public InnerFiled.Builder SetVal(string value)
			{
				ThrowHelper.ThrowIfNull(value, "value");
				this.PrepareBuilder();
				this.result.hasVal = true;
				this.result.val_ = value;
				return this;
			}

			// Token: 0x06000A7A RID: 2682 RVA: 0x00018A44 File Offset: 0x00016C44
			public InnerFiled.Builder ClearVal()
			{
				this.PrepareBuilder();
				this.result.hasVal = false;
				this.result.val_ = "";
				return this;
			}

			// Token: 0x17000423 RID: 1059
			// (get) Token: 0x06000A7B RID: 2683 RVA: 0x00018A6A File Offset: 0x00016C6A
			public bool HasType
			{
				get
				{
					return this.result.hasType;
				}
			}

			// Token: 0x17000424 RID: 1060
			// (get) Token: 0x06000A7C RID: 2684 RVA: 0x00018A77 File Offset: 0x00016C77
			// (set) Token: 0x06000A7D RID: 2685 RVA: 0x00018A84 File Offset: 0x00016C84
			public InnerFiled.Types.Type Type
			{
				get
				{
					return this.result.Type;
				}
				set
				{
					this.SetType(value);
				}
			}

			// Token: 0x06000A7E RID: 2686 RVA: 0x00018A8E File Offset: 0x00016C8E
			public InnerFiled.Builder SetType(InnerFiled.Types.Type value)
			{
				this.PrepareBuilder();
				this.result.hasType = true;
				this.result.type_ = value;
				return this;
			}

			// Token: 0x06000A7F RID: 2687 RVA: 0x00018AB0 File Offset: 0x00016CB0
			public InnerFiled.Builder ClearType()
			{
				this.PrepareBuilder();
				this.result.hasType = false;
				this.result.type_ = InnerFiled.Types.Type.str;
				return this;
			}

			// Token: 0x0400036D RID: 877
			private bool resultIsReadOnly;

			// Token: 0x0400036E RID: 878
			private InnerFiled result;
		}
	}
}
